home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Python 1.3.3 / Python 133 SRC / Mac / Modules / dlg / Dlgmodule.c < prev    next >
Text File  |  1996-04-12  |  23KB  |  939 lines
  1.  
  2. /* =========================== Module Dlg =========================== */
  3.  
  4. #include "Python.h"
  5.  
  6.  
  7.  
  8. #define SystemSevenOrLater 1
  9.  
  10. #include "macglue.h"
  11. #include <Memory.h>
  12. #include <Dialogs.h>
  13. #include <Menus.h>
  14. #include <Controls.h>
  15.  
  16. extern PyObject *ResObj_New(Handle);
  17. extern int ResObj_Convert(PyObject *, Handle *);
  18. extern PyObject *OptResObj_New(Handle);
  19. extern int OptResObj_Convert(PyObject *, Handle *);
  20.  
  21. extern PyObject *WinObj_New(WindowPtr);
  22. extern int WinObj_Convert(PyObject *, WindowPtr *);
  23. extern PyTypeObject Window_Type;
  24. #define WinObj_Check(x) ((x)->ob_type == &Window_Type)
  25.  
  26. extern PyObject *DlgObj_New(DialogPtr);
  27. extern int DlgObj_Convert(PyObject *, DialogPtr *);
  28. extern PyTypeObject Dialog_Type;
  29. #define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type)
  30.  
  31. extern PyObject *MenuObj_New(MenuHandle);
  32. extern int MenuObj_Convert(PyObject *, MenuHandle *);
  33.  
  34. extern PyObject *CtlObj_New(ControlHandle);
  35. extern int CtlObj_Convert(PyObject *, ControlHandle *);
  36.  
  37. extern PyObject *GrafObj_New(GrafPtr);
  38. extern int GrafObj_Convert(PyObject *, GrafPtr *);
  39.  
  40. extern PyObject *BMObj_New(BitMapPtr);
  41. extern int BMObj_Convert(PyObject *, BitMapPtr *);
  42.  
  43. extern PyObject *PMObj_New(PixMapHandle);
  44. extern int PMObj_Convert(PyObject *, PixMapHandle *);
  45.  
  46. extern PyObject *WinObj_WhichWindow(WindowPtr);
  47.  
  48. #include <Dialogs.h>
  49.  
  50. #ifndef HAVE_UNIVERSAL_HEADERS
  51. #define NewModalFilterProc(x) (x)
  52. #endif
  53.  
  54. #define resNotFound -192 /* Can't include <Errors.h> because of Python's "errors.h" */
  55.  
  56. /* XXX Shouldn't this be a stack? */
  57. static PyObject *Dlg_FilterProc_callback = NULL;
  58.  
  59. static PyObject *DlgObj_New(DialogPtr); /* Forward */
  60.  
  61. static pascal Boolean Dlg_UnivFilterProc(DialogPtr dialog,
  62.                                          EventRecord *event,
  63.                                          short *itemHit)
  64. {
  65.     Boolean rv;
  66.     PyObject *args, *res;
  67.     PyObject *callback = Dlg_FilterProc_callback;
  68.     if (callback == NULL)
  69.         return 0; /* Default behavior */
  70.     Dlg_FilterProc_callback = NULL; /* We'll restore it when call successful */
  71.     args = Py_BuildValue("O&O&", WinObj_WhichWindow, dialog, PyMac_BuildEventRecord, event);
  72.     if (args == NULL)
  73.         res = NULL;
  74.     else {
  75.         res = PyEval_CallObject(callback, args);
  76.         Py_DECREF(args);
  77.     }
  78.     if (res == NULL) {
  79.         fprintf(stderr, "Exception in Dialog Filter\n");
  80.         PyErr_Print();
  81.         *itemHit = -1; /* Fake return item */
  82.         return 1; /* We handled it */
  83.     }
  84.     else {
  85.         Dlg_FilterProc_callback = callback;
  86.         if (PyInt_Check(res)) {
  87.             *itemHit = PyInt_AsLong(res);
  88.             rv = 1;
  89.         }
  90.         else
  91.             rv = PyObject_IsTrue(res);
  92.     }
  93.     Py_DECREF(res);
  94.     return rv;
  95. }
  96.  
  97. static ModalFilterProcPtr
  98. Dlg_PassFilterProc(PyObject *callback)
  99. {
  100.     PyObject *tmp = Dlg_FilterProc_callback;
  101.     Dlg_FilterProc_callback = NULL;
  102.     if (callback == Py_None) {
  103.         Py_XDECREF(tmp);
  104.         return NULL;
  105.     }
  106.     Py_INCREF(callback);
  107.     Dlg_FilterProc_callback = callback;
  108.     Py_XDECREF(tmp);
  109.     return &Dlg_UnivFilterProc;
  110. }
  111.  
  112. extern PyMethodChain WinObj_chain;
  113.  
  114. static PyObject *Dlg_Error;
  115.  
  116. /* ----------------------- Object type Dialog ----------------------- */
  117.  
  118. PyTypeObject Dialog_Type;
  119.  
  120. #define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type)
  121.  
  122. typedef struct DialogObject {
  123.     PyObject_HEAD
  124.     DialogPtr ob_itself;
  125. } DialogObject;
  126.  
  127. PyObject *DlgObj_New(itself)
  128.     DialogPtr itself;
  129. {
  130.     DialogObject *it;
  131.     if (itself == NULL) return Py_None;
  132.     it = PyObject_NEW(DialogObject, &Dialog_Type);
  133.     if (it == NULL) return NULL;
  134.     it->ob_itself = itself;
  135.     SetWRefCon(itself, (long)it);
  136.     return (PyObject *)it;
  137. }
  138. DlgObj_Convert(v, p_itself)
  139.     PyObject *v;
  140.     DialogPtr *p_itself;
  141. {
  142.     if (v == Py_None) { *p_itself = NULL; return 1; }
  143.     if (PyInt_Check(v)) { *p_itself = (DialogPtr)PyInt_AsLong(v);
  144.                           return 1; }
  145.     if (!DlgObj_Check(v))
  146.     {
  147.         PyErr_SetString(PyExc_TypeError, "Dialog required");
  148.         return 0;
  149.     }
  150.     *p_itself = ((DialogObject *)v)->ob_itself;
  151.     return 1;
  152. }
  153.  
  154. static void DlgObj_dealloc(self)
  155.     DialogObject *self;
  156. {
  157.     DisposeDialog(self->ob_itself);
  158.     PyMem_DEL(self);
  159. }
  160.  
  161. static PyObject *DlgObj_DrawDialog(_self, _args)
  162.     DialogObject *_self;
  163.     PyObject *_args;
  164. {
  165.     PyObject *_res = NULL;
  166.     if (!PyArg_ParseTuple(_args, ""))
  167.         return NULL;
  168.     DrawDialog(_self->ob_itself);
  169.     Py_INCREF(Py_None);
  170.     _res = Py_None;
  171.     return _res;
  172. }
  173.  
  174. static PyObject *DlgObj_UpdateDialog(_self, _args)
  175.     DialogObject *_self;
  176.     PyObject *_args;
  177. {
  178.     PyObject *_res = NULL;
  179.     RgnHandle updateRgn;
  180.     if (!PyArg_ParseTuple(_args, "O&",
  181.                           ResObj_Convert, &updateRgn))
  182.         return NULL;
  183.     UpdateDialog(_self->ob_itself,
  184.                  updateRgn);
  185.     Py_INCREF(Py_None);
  186.     _res = Py_None;
  187.     return _res;
  188. }
  189.  
  190. static PyObject *DlgObj_GetDialogItem(_self, _args)
  191.     DialogObject *_self;
  192.     PyObject *_args;
  193. {
  194.     PyObject *_res = NULL;
  195.     short itemNo;
  196.     short itemType;
  197.     Handle item;
  198.     Rect box;
  199.     if (!PyArg_ParseTuple(_args, "h",
  200.                           &itemNo))
  201.         return NULL;
  202.     GetDialogItem(_self->ob_itself,
  203.                   itemNo,
  204.                   &itemType,
  205.                   &item,
  206.                   &box);
  207.     _res = Py_BuildValue("hO&O&",
  208.                          itemType,
  209.                          OptResObj_New, item,
  210.                          PyMac_BuildRect, &box);
  211.     return _res;
  212. }
  213.  
  214. static PyObject *DlgObj_SetDialogItem(_self, _args)
  215.     DialogObject *_self;
  216.     PyObject *_args;
  217. {
  218.     PyObject *_res = NULL;
  219.     short itemNo;
  220.     short itemType;
  221.     Handle item;
  222.     Rect box;
  223.     if (!PyArg_ParseTuple(_args, "hhO&O&",
  224.                           &itemNo,
  225.                           &itemType,
  226.                           ResObj_Convert, &item,
  227.                           PyMac_GetRect, &box))
  228.         return NULL;
  229.     SetDialogItem(_self->ob_itself,
  230.                   itemNo,
  231.                   itemType,
  232.                   item,
  233.                   &box);
  234.     Py_INCREF(Py_None);
  235.     _res = Py_None;
  236.     return _res;
  237. }
  238.  
  239. static PyObject *DlgObj_HideDialogItem(_self, _args)
  240.     DialogObject *_self;
  241.     PyObject *_args;
  242. {
  243.     PyObject *_res = NULL;
  244.     short itemNo;
  245.     if (!PyArg_ParseTuple(_args, "h",
  246.                           &itemNo))
  247.         return NULL;
  248.     HideDialogItem(_self->ob_itself,
  249.                    itemNo);
  250.     Py_INCREF(Py_None);
  251.     _res = Py_None;
  252.     return _res;
  253. }
  254.  
  255. static PyObject *DlgObj_ShowDialogItem(_self, _args)
  256.     DialogObject *_self;
  257.     PyObject *_args;
  258. {
  259.     PyObject *_res = NULL;
  260.     short itemNo;
  261.     if (!PyArg_ParseTuple(_args, "h",
  262.                           &itemNo))
  263.         return NULL;
  264.     ShowDialogItem(_self->ob_itself,
  265.                    itemNo);
  266.     Py_INCREF(Py_None);
  267.     _res = Py_None;
  268.     return _res;
  269. }
  270.  
  271. static PyObject *DlgObj_SelectDialogItemText(_self, _args)
  272.     DialogObject *_self;
  273.     PyObject *_args;
  274. {
  275.     PyObject *_res = NULL;
  276.     short itemNo;
  277.     short strtSel;
  278.     short endSel;
  279.     if (!PyArg_ParseTuple(_args, "hhh",
  280.                           &itemNo,
  281.                           &strtSel,
  282.                           &endSel))
  283.         return NULL;
  284.     SelectDialogItemText(_self->ob_itself,
  285.                          itemNo,
  286.                          strtSel,
  287.                          endSel);
  288.     Py_INCREF(Py_None);
  289.     _res = Py_None;
  290.     return _res;
  291. }
  292.  
  293. static PyObject *DlgObj_FindDialogItem(_self, _args)
  294.     DialogObject *_self;
  295.     PyObject *_args;
  296. {
  297.     PyObject *_res = NULL;
  298.     short _rv;
  299.     Point thePt;
  300.     if (!PyArg_ParseTuple(_args, "O&",
  301.                           PyMac_GetPoint, &thePt))
  302.         return NULL;
  303.     _rv = FindDialogItem(_self->ob_itself,
  304.                          thePt);
  305.     _res = Py_BuildValue("h",
  306.                          _rv);
  307.     return _res;
  308. }
  309.  
  310. static PyObject *DlgObj_DialogCut(_self, _args)
  311.     DialogObject *_self;
  312.     PyObject *_args;
  313. {
  314.     PyObject *_res = NULL;
  315.     if (!PyArg_ParseTuple(_args, ""))
  316.         return NULL;
  317.     DialogCut(_self->ob_itself);
  318.     Py_INCREF(Py_None);
  319.     _res = Py_None;
  320.     return _res;
  321. }
  322.  
  323. static PyObject *DlgObj_DialogPaste(_self, _args)
  324.     DialogObject *_self;
  325.     PyObject *_args;
  326. {
  327.     PyObject *_res = NULL;
  328.     if (!PyArg_ParseTuple(_args, ""))
  329.         return NULL;
  330.     DialogPaste(_self->ob_itself);
  331.     Py_INCREF(Py_None);
  332.     _res = Py_None;
  333.     return _res;
  334. }
  335.  
  336. static PyObject *DlgObj_DialogCopy(_self, _args)
  337.     DialogObject *_self;
  338.     PyObject *_args;
  339. {
  340.     PyObject *_res = NULL;
  341.     if (!PyArg_ParseTuple(_args, ""))
  342.         return NULL;
  343.     DialogCopy(_self->ob_itself);
  344.     Py_INCREF(Py_None);
  345.     _res = Py_None;
  346.     return _res;
  347. }
  348.  
  349. static PyObject *DlgObj_DialogDelete(_self, _args)
  350.     DialogObject *_self;
  351.     PyObject *_args;
  352. {
  353.     PyObject *_res = NULL;
  354.     if (!PyArg_ParseTuple(_args, ""))
  355.         return NULL;
  356.     DialogDelete(_self->ob_itself);
  357.     Py_INCREF(Py_None);
  358.     _res = Py_None;
  359.     return _res;
  360. }
  361.  
  362. static PyObject *DlgObj_AppendDITL(_self, _args)
  363.     DialogObject *_self;
  364.     PyObject *_args;
  365. {
  366.     PyObject *_res = NULL;
  367.     Handle theHandle;
  368.     DITLMethod method;
  369.     if (!PyArg_ParseTuple(_args, "O&h",
  370.                           ResObj_Convert, &theHandle,
  371.                           &method))
  372.         return NULL;
  373.     AppendDITL(_self->ob_itself,
  374.                theHandle,
  375.                method);
  376.     Py_INCREF(Py_None);
  377.     _res = Py_None;
  378.     return _res;
  379. }
  380.  
  381. static PyObject *DlgObj_CountDITL(_self, _args)
  382.     DialogObject *_self;
  383.     PyObject *_args;
  384. {
  385.     PyObject *_res = NULL;
  386.     short _rv;
  387.     if (!PyArg_ParseTuple(_args, ""))
  388.         return NULL;
  389.     _rv = CountDITL(_self->ob_itself);
  390.     _res = Py_BuildValue("h",
  391.                          _rv);
  392.     return _res;
  393. }
  394.  
  395. static PyObject *DlgObj_ShortenDITL(_self, _args)
  396.     DialogObject *_self;
  397.     PyObject *_args;
  398. {
  399.     PyObject *_res = NULL;
  400.     short numberItems;
  401.     if (!PyArg_ParseTuple(_args, "h",
  402.                           &numberItems))
  403.         return NULL;
  404.     ShortenDITL(_self->ob_itself,
  405.                 numberItems);
  406.     Py_INCREF(Py_None);
  407.     _res = Py_None;
  408.     return _res;
  409. }
  410.  
  411. static PyObject *DlgObj_StdFilterProc(_self, _args)
  412.     DialogObject *_self;
  413.     PyObject *_args;
  414. {
  415.     PyObject *_res = NULL;
  416.     Boolean _rv;
  417.     EventRecord event;
  418.     short itemHit;
  419.     if (!PyArg_ParseTuple(_args, ""))
  420.         return NULL;
  421.     _rv = StdFilterProc(_self->ob_itself,
  422.                         &event,
  423.                         &itemHit);
  424.     _res = Py_BuildValue("bO&h",
  425.                          _rv,
  426.                          PyMac_BuildEventRecord, &event,
  427.                          itemHit);
  428.     return _res;
  429. }
  430.  
  431. static PyObject *DlgObj_SetDialogDefaultItem(_self, _args)
  432.     DialogObject *_self;
  433.     PyObject *_args;
  434. {
  435.     PyObject *_res = NULL;
  436.     OSErr _err;
  437.     short newItem;
  438.     if (!PyArg_ParseTuple(_args, "h",
  439.                           &newItem))
  440.         return NULL;
  441.     _err = SetDialogDefaultItem(_self->ob_itself,
  442.                                 newItem);
  443.     if (_err != noErr) return PyMac_Error(_err);
  444.     Py_INCREF(Py_None);
  445.     _res = Py_None;
  446.     return _res;
  447. }
  448.  
  449. static PyObject *DlgObj_SetDialogCancelItem(_self, _args)
  450.     DialogObject *_self;
  451.     PyObject *_args;
  452. {
  453.     PyObject *_res = NULL;
  454.     OSErr _err;
  455.     short newItem;
  456.     if (!PyArg_ParseTuple(_args, "h",
  457.                           &newItem))
  458.         return NULL;
  459.     _err = SetDialogCancelItem(_self->ob_itself,
  460.                                newItem);
  461.     if (_err != noErr) return PyMac_Error(_err);
  462.     Py_INCREF(Py_None);
  463.     _res = Py_None;
  464.     return _res;
  465. }
  466.  
  467. static PyObject *DlgObj_SetDialogTracksCursor(_self, _args)
  468.     DialogObject *_self;
  469.     PyObject *_args;
  470. {
  471.     PyObject *_res = NULL;
  472.     OSErr _err;
  473.     Boolean tracks;
  474.     if (!PyArg_ParseTuple(_args, "b",
  475.                           &tracks))
  476.         return NULL;
  477.     _err = SetDialogTracksCursor(_self->ob_itself,
  478.                                  tracks);
  479.     if (_err != noErr) return PyMac_Error(_err);
  480.     Py_INCREF(Py_None);
  481.     _res = Py_None;
  482.     return _res;
  483. }
  484.  
  485. static PyMethodDef DlgObj_methods[] = {
  486.     {"DrawDialog", (PyCFunction)DlgObj_DrawDialog, 1,
  487.      "() -> None"},
  488.     {"UpdateDialog", (PyCFunction)DlgObj_UpdateDialog, 1,
  489.      "(RgnHandle updateRgn) -> None"},
  490.     {"GetDialogItem", (PyCFunction)DlgObj_GetDialogItem, 1,
  491.      "(short itemNo) -> (short itemType, Handle item, Rect box)"},
  492.     {"SetDialogItem", (PyCFunction)DlgObj_SetDialogItem, 1,
  493.      "(short itemNo, short itemType, Handle item, Rect box) -> None"},
  494.     {"HideDialogItem", (PyCFunction)DlgObj_HideDialogItem, 1,
  495.      "(short itemNo) -> None"},
  496.     {"ShowDialogItem", (PyCFunction)DlgObj_ShowDialogItem, 1,
  497.      "(short itemNo) -> None"},
  498.     {"SelectDialogItemText", (PyCFunction)DlgObj_SelectDialogItemText, 1,
  499.      "(short itemNo, short strtSel, short endSel) -> None"},
  500.     {"FindDialogItem", (PyCFunction)DlgObj_FindDialogItem, 1,
  501.      "(Point thePt) -> (short _rv)"},
  502.     {"DialogCut", (PyCFunction)DlgObj_DialogCut, 1,
  503.      "() -> None"},
  504.     {"DialogPaste", (PyCFunction)DlgObj_DialogPaste, 1,
  505.      "() -> None"},
  506.     {"DialogCopy", (PyCFunction)DlgObj_DialogCopy, 1,
  507.      "() -> None"},
  508.     {"DialogDelete", (PyCFunction)DlgObj_DialogDelete, 1,
  509.      "() -> None"},
  510.     {"AppendDITL", (PyCFunction)DlgObj_AppendDITL, 1,
  511.      "(Handle theHandle, DITLMethod method) -> None"},
  512.     {"CountDITL", (PyCFunction)DlgObj_CountDITL, 1,
  513.      "() -> (short _rv)"},
  514.     {"ShortenDITL", (PyCFunction)DlgObj_ShortenDITL, 1,
  515.      "(short numberItems) -> None"},
  516.     {"StdFilterProc", (PyCFunction)DlgObj_StdFilterProc, 1,
  517.      "() -> (Boolean _rv, EventRecord event, short itemHit)"},
  518.     {"SetDialogDefaultItem", (PyCFunction)DlgObj_SetDialogDefaultItem, 1,
  519.      "(short newItem) -> None"},
  520.     {"SetDialogCancelItem", (PyCFunction)DlgObj_SetDialogCancelItem, 1,
  521.      "(short newItem) -> None"},
  522.     {"SetDialogTracksCursor", (PyCFunction)DlgObj_SetDialogTracksCursor, 1,
  523.      "(Boolean tracks) -> None"},
  524.     {NULL, NULL, 0}
  525. };
  526.  
  527. PyMethodChain DlgObj_chain = { DlgObj_methods, &WinObj_chain };
  528.  
  529. static PyObject *DlgObj_getattr(self, name)
  530.     DialogObject *self;
  531.     char *name;
  532. {
  533.     return Py_FindMethodInChain(&DlgObj_chain, (PyObject *)self, name);
  534. }
  535.  
  536. #define DlgObj_setattr NULL
  537.  
  538. PyTypeObject Dialog_Type = {
  539.     PyObject_HEAD_INIT(&PyType_Type)
  540.     0, /*ob_size*/
  541.     "Dialog", /*tp_name*/
  542.     sizeof(DialogObject), /*tp_basicsize*/
  543.     0, /*tp_itemsize*/
  544.     /* methods */
  545.     (destructor) DlgObj_dealloc, /*tp_dealloc*/
  546.     0, /*tp_print*/
  547.     (getattrfunc) DlgObj_getattr, /*tp_getattr*/
  548.     (setattrfunc) DlgObj_setattr, /*tp_setattr*/
  549. };
  550.  
  551. /* --------------------- End object type Dialog --------------------- */
  552.  
  553.  
  554. static PyObject *Dlg_NewDialog(_self, _args)
  555.     PyObject *_self;
  556.     PyObject *_args;
  557. {
  558.     PyObject *_res = NULL;
  559.     DialogPtr _rv;
  560.     Rect boundsRect;
  561.     Str255 title;
  562.     Boolean visible;
  563.     short procID;
  564.     WindowPtr behind;
  565.     Boolean goAwayFlag;
  566.     long refCon;
  567.     Handle itmLstHndl;
  568.     if (!PyArg_ParseTuple(_args, "O&O&bhO&blO&",
  569.                           PyMac_GetRect, &boundsRect,
  570.                           PyMac_GetStr255, title,
  571.                           &visible,
  572.                           &procID,
  573.                           WinObj_Convert, &behind,
  574.                           &goAwayFlag,
  575.                           &refCon,
  576.                           ResObj_Convert, &itmLstHndl))
  577.         return NULL;
  578.     _rv = NewDialog((void *)0,
  579.                     &boundsRect,
  580.                     title,
  581.                     visible,
  582.                     procID,
  583.                     behind,
  584.                     goAwayFlag,
  585.                     refCon,
  586.                     itmLstHndl);
  587.     _res = Py_BuildValue("O&",
  588.                          DlgObj_New, _rv);
  589.     return _res;
  590. }
  591.  
  592. static PyObject *Dlg_GetNewDialog(_self, _args)
  593.     PyObject *_self;
  594.     PyObject *_args;
  595. {
  596.     PyObject *_res = NULL;
  597.     DialogPtr _rv;
  598.     short dialogID;
  599.     WindowPtr behind;
  600.     if (!PyArg_ParseTuple(_args, "hO&",
  601.                           &dialogID,
  602.                           WinObj_Convert, &behind))
  603.         return NULL;
  604.     _rv = GetNewDialog(dialogID,
  605.                        (void *)0,
  606.                        behind);
  607.     _res = Py_BuildValue("O&",
  608.                          DlgObj_New, _rv);
  609.     return _res;
  610. }
  611.  
  612. static PyObject *Dlg_ParamText(_self, _args)
  613.     PyObject *_self;
  614.     PyObject *_args;
  615. {
  616.     PyObject *_res = NULL;
  617.     Str255 param0;
  618.     Str255 param1;
  619.     Str255 param2;
  620.     Str255 param3;
  621.     if (!PyArg_ParseTuple(_args, "O&O&O&O&",
  622.                           PyMac_GetStr255, param0,
  623.                           PyMac_GetStr255, param1,
  624.                           PyMac_GetStr255, param2,
  625.                           PyMac_GetStr255, param3))
  626.         return NULL;
  627.     ParamText(param0,
  628.               param1,
  629.               param2,
  630.               param3);
  631.     Py_INCREF(Py_None);
  632.     _res = Py_None;
  633.     return _res;
  634. }
  635.  
  636. static PyObject *Dlg_ModalDialog(_self, _args)
  637.     PyObject *_self;
  638.     PyObject *_args;
  639. {
  640.     PyObject *_res = NULL;
  641.     PyObject* modalFilter;
  642.     short itemHit;
  643.     if (!PyArg_ParseTuple(_args, "O",
  644.                           &modalFilter))
  645.         return NULL;
  646.     ModalDialog(NewModalFilterProc(Dlg_PassFilterProc(modalFilter)),
  647.                 &itemHit);
  648.     _res = Py_BuildValue("h",
  649.                          itemHit);
  650.     return _res;
  651. }
  652.  
  653. static PyObject *Dlg_IsDialogEvent(_self, _args)
  654.     PyObject *_self;
  655.     PyObject *_args;
  656. {
  657.     PyObject *_res = NULL;
  658.     Boolean _rv;
  659.     EventRecord theEvent;
  660.     if (!PyArg_ParseTuple(_args, "O&",
  661.                           PyMac_GetEventRecord, &theEvent))
  662.         return NULL;
  663.     _rv = IsDialogEvent(&theEvent);
  664.     _res = Py_BuildValue("b",
  665.                          _rv);
  666.     return _res;
  667. }
  668.  
  669. static PyObject *Dlg_DialogSelect(_self, _args)
  670.     PyObject *_self;
  671.     PyObject *_args;
  672. {
  673.     PyObject *_res = NULL;
  674.     Boolean _rv;
  675.     EventRecord theEvent;
  676.     DialogPtr theDialog;
  677.     short itemHit;
  678.     if (!PyArg_ParseTuple(_args, "O&",
  679.                           PyMac_GetEventRecord, &theEvent))
  680.         return NULL;
  681.     _rv = DialogSelect(&theEvent,
  682.                        &theDialog,
  683.                        &itemHit);
  684.     _res = Py_BuildValue("bO&h",
  685.                          _rv,
  686.                          WinObj_WhichWindow, theDialog,
  687.                          itemHit);
  688.     return _res;
  689. }
  690.  
  691. static PyObject *Dlg_Alert(_self, _args)
  692.     PyObject *_self;
  693.     PyObject *_args;
  694. {
  695.     PyObject *_res = NULL;
  696.     short _rv;
  697.     short alertID;
  698.     PyObject* modalFilter;
  699.     if (!PyArg_ParseTuple(_args, "hO",
  700.                           &alertID,
  701.                           &modalFilter))
  702.         return NULL;
  703.     _rv = Alert(alertID,
  704.                 NewModalFilterProc(Dlg_PassFilterProc(modalFilter)));
  705.     _res = Py_BuildValue("h",
  706.                          _rv);
  707.     return _res;
  708. }
  709.  
  710. static PyObject *Dlg_StopAlert(_self, _args)
  711.     PyObject *_self;
  712.     PyObject *_args;
  713. {
  714.     PyObject *_res = NULL;
  715.     short _rv;
  716.     short alertID;
  717.     PyObject* modalFilter;
  718.     if (!PyArg_ParseTuple(_args, "hO",
  719.                           &alertID,
  720.                           &modalFilter))
  721.         return NULL;
  722.     _rv = StopAlert(alertID,
  723.                     NewModalFilterProc(Dlg_PassFilterProc(modalFilter)));
  724.     _res = Py_BuildValue("h",
  725.                          _rv);
  726.     return _res;
  727. }
  728.  
  729. static PyObject *Dlg_NoteAlert(_self, _args)
  730.     PyObject *_self;
  731.     PyObject *_args;
  732. {
  733.     PyObject *_res = NULL;
  734.     short _rv;
  735.     short alertID;
  736.     PyObject* modalFilter;
  737.     if (!PyArg_ParseTuple(_args, "hO",
  738.                           &alertID,
  739.                           &modalFilter))
  740.         return NULL;
  741.     _rv = NoteAlert(alertID,
  742.                     NewModalFilterProc(Dlg_PassFilterProc(modalFilter)));
  743.     _res = Py_BuildValue("h",
  744.                          _rv);
  745.     return _res;
  746. }
  747.  
  748. static PyObject *Dlg_CautionAlert(_self, _args)
  749.     PyObject *_self;
  750.     PyObject *_args;
  751. {
  752.     PyObject *_res = NULL;
  753.     short _rv;
  754.     short alertID;
  755.     PyObject* modalFilter;
  756.     if (!PyArg_ParseTuple(_args, "hO",
  757.                           &alertID,
  758.                           &modalFilter))
  759.         return NULL;
  760.     _rv = CautionAlert(alertID,
  761.                        NewModalFilterProc(Dlg_PassFilterProc(modalFilter)));
  762.     _res = Py_BuildValue("h",
  763.                          _rv);
  764.     return _res;
  765. }
  766.  
  767. static PyObject *Dlg_GetDialogItemText(_self, _args)
  768.     PyObject *_self;
  769.     PyObject *_args;
  770. {
  771.     PyObject *_res = NULL;
  772.     Handle item;
  773.     Str255 text;
  774.     if (!PyArg_ParseTuple(_args, "O&",
  775.                           ResObj_Convert, &item))
  776.         return NULL;
  777.     GetDialogItemText(item,
  778.                       text);
  779.     _res = Py_BuildValue("O&",
  780.                          PyMac_BuildStr255, text);
  781.     return _res;
  782. }
  783.  
  784. static PyObject *Dlg_SetDialogItemText(_self, _args)
  785.     PyObject *_self;
  786.     PyObject *_args;
  787. {
  788.     PyObject *_res = NULL;
  789.     Handle item;
  790.     Str255 text;
  791.     if (!PyArg_ParseTuple(_args, "O&O&",
  792.                           ResObj_Convert, &item,
  793.                           PyMac_GetStr255, text))
  794.         return NULL;
  795.     SetDialogItemText(item,
  796.                       text);
  797.     Py_INCREF(Py_None);
  798.     _res = Py_None;
  799.     return _res;
  800. }
  801.  
  802. static PyObject *Dlg_NewColorDialog(_self, _args)
  803.     PyObject *_self;
  804.     PyObject *_args;
  805. {
  806.     PyObject *_res = NULL;
  807.     DialogPtr _rv;
  808.     Rect boundsRect;
  809.     Str255 title;
  810.     Boolean visible;
  811.     short procID;
  812.     WindowPtr behind;
  813.     Boolean goAwayFlag;
  814.     long refCon;
  815.     Handle items;
  816.     if (!PyArg_ParseTuple(_args, "O&O&bhO&blO&",
  817.                           PyMac_GetRect, &boundsRect,
  818.                           PyMac_GetStr255, title,
  819.                           &visible,
  820.                           &procID,
  821.                           WinObj_Convert, &behind,
  822.                           &goAwayFlag,
  823.                           &refCon,
  824.                           ResObj_Convert, &items))
  825.         return NULL;
  826.     _rv = NewColorDialog((void *)0,
  827.                          &boundsRect,
  828.                          title,
  829.                          visible,
  830.                          procID,
  831.                          behind,
  832.                          goAwayFlag,
  833.                          refCon,
  834.                          items);
  835.     _res = Py_BuildValue("O&",
  836.                          DlgObj_New, _rv);
  837.     return _res;
  838. }
  839.  
  840. static PyObject *Dlg_GetAlertStage(_self, _args)
  841.     PyObject *_self;
  842.     PyObject *_args;
  843. {
  844.     PyObject *_res = NULL;
  845.     short _rv;
  846.     if (!PyArg_ParseTuple(_args, ""))
  847.         return NULL;
  848.     _rv = GetAlertStage();
  849.     _res = Py_BuildValue("h",
  850.                          _rv);
  851.     return _res;
  852. }
  853.  
  854. static PyObject *Dlg_ResetAlertStage(_self, _args)
  855.     PyObject *_self;
  856.     PyObject *_args;
  857. {
  858.     PyObject *_res = NULL;
  859.     if (!PyArg_ParseTuple(_args, ""))
  860.         return NULL;
  861.     ResetAlertStage();
  862.     Py_INCREF(Py_None);
  863.     _res = Py_None;
  864.     return _res;
  865. }
  866.  
  867. static PyObject *Dlg_SetDialogFont(_self, _args)
  868.     PyObject *_self;
  869.     PyObject *_args;
  870. {
  871.     PyObject *_res = NULL;
  872.     short value;
  873.     if (!PyArg_ParseTuple(_args, "h",
  874.                           &value))
  875.         return NULL;
  876.     SetDialogFont(value);
  877.     Py_INCREF(Py_None);
  878.     _res = Py_None;
  879.     return _res;
  880. }
  881.  
  882. static PyMethodDef Dlg_methods[] = {
  883.     {"NewDialog", (PyCFunction)Dlg_NewDialog, 1,
  884.      "(Rect boundsRect, Str255 title, Boolean visible, short procID, WindowPtr behind, Boolean goAwayFlag, long refCon, Handle itmLstHndl) -> (DialogPtr _rv)"},
  885.     {"GetNewDialog", (PyCFunction)Dlg_GetNewDialog, 1,
  886.      "(short dialogID, WindowPtr behind) -> (DialogPtr _rv)"},
  887.     {"ParamText", (PyCFunction)Dlg_ParamText, 1,
  888.      "(Str255 param0, Str255 param1, Str255 param2, Str255 param3) -> None"},
  889.     {"ModalDialog", (PyCFunction)Dlg_ModalDialog, 1,
  890.      "(PyObject* modalFilter) -> (short itemHit)"},
  891.     {"IsDialogEvent", (PyCFunction)Dlg_IsDialogEvent, 1,
  892.      "(EventRecord theEvent) -> (Boolean _rv)"},
  893.     {"DialogSelect", (PyCFunction)Dlg_DialogSelect, 1,
  894.      "(EventRecord theEvent) -> (Boolean _rv, DialogPtr theDialog, short itemHit)"},
  895.     {"Alert", (PyCFunction)Dlg_Alert, 1,
  896.      "(short alertID, PyObject* modalFilter) -> (short _rv)"},
  897.     {"StopAlert", (PyCFunction)Dlg_StopAlert, 1,
  898.      "(short alertID, PyObject* modalFilter) -> (short _rv)"},
  899.     {"NoteAlert", (PyCFunction)Dlg_NoteAlert, 1,
  900.      "(short alertID, PyObject* modalFilter) -> (short _rv)"},
  901.     {"CautionAlert", (PyCFunction)Dlg_CautionAlert, 1,
  902.      "(short alertID, PyObject* modalFilter) -> (short _rv)"},
  903.     {"GetDialogItemText", (PyCFunction)Dlg_GetDialogItemText, 1,
  904.      "(Handle item) -> (Str255 text)"},
  905.     {"SetDialogItemText", (PyCFunction)Dlg_SetDialogItemText, 1,
  906.      "(Handle item, Str255 text) -> None"},
  907.     {"NewColorDialog", (PyCFunction)Dlg_NewColorDialog, 1,
  908.      "(Rect boundsRect, Str255 title, Boolean visible, short procID, WindowPtr behind, Boolean goAwayFlag, long refCon, Handle items) -> (DialogPtr _rv)"},
  909.     {"GetAlertStage", (PyCFunction)Dlg_GetAlertStage, 1,
  910.      "() -> (short _rv)"},
  911.     {"ResetAlertStage", (PyCFunction)Dlg_ResetAlertStage, 1,
  912.      "() -> None"},
  913.     {"SetDialogFont", (PyCFunction)Dlg_SetDialogFont, 1,
  914.      "(short value) -> None"},
  915.     {NULL, NULL, 0}
  916. };
  917.  
  918.  
  919.  
  920.  
  921. void initDlg()
  922. {
  923.     PyObject *m;
  924.     PyObject *d;
  925.  
  926.  
  927.  
  928.  
  929.     m = Py_InitModule("Dlg", Dlg_methods);
  930.     d = PyModule_GetDict(m);
  931.     Dlg_Error = PyMac_GetOSErrException();
  932.     if (Dlg_Error == NULL ||
  933.         PyDict_SetItemString(d, "Error", Dlg_Error) != 0)
  934.         Py_FatalError("can't initialize Dlg.Error");
  935. }
  936.  
  937. /* ========================= End module Dlg ========================= */
  938.  
  939.